home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / Libraries / C Internet Config / IC Component Debug ƒ / IC Resource ƒ / Syslog Component ƒ / syslog.c < prev    next >
Encoding:
Text File  |  1995-11-15  |  9.7 KB  |  273 lines  |  [TEXT/SPM ]
  1.     return;
  2.     
  3.     if (_gSyslogComponent!=(ComponentInstance)0)
  4.         return; // already initialized
  5.     
  6.     _gSyslogBuf=(char*)NewPtr(4096*2); // allocate an 8k buffer
  7.     
  8.     if (_gSyslogBuf==(char*)0)
  9.         return;
  10.     
  11.     
  12.     desc.componentType=ksyslogComponentType;
  13.     desc.componentSubType=kAnyComponentType;
  14.     desc.componentManufacturer=kAnyComponentType;
  15.     desc.componentFlags=kAnyComponentType;
  16.     desc.componentFlagsMask=kAnyComponentType;
  17.     
  18.     theComp=FindNextComponent((Component)0,&desc);
  19.     
  20.     if (theComp!=(Component)0){
  21.         
  22.         _gSyslogComponent=OpenComponent(theComp);
  23.         
  24.         if (_gSyslogComponent==(ComponentInstance)0){
  25.             DisposePtr((Ptr)_gSyslogBuf);
  26.             return;
  27.         }
  28.         
  29.         _gSyslog_newETS=NewExitToShellProc(SyslogAtExit);
  30.         
  31. #if defined(powerc)||defined(__powerc)
  32.         // nothing special here
  33. #else
  34.         // 68k code
  35.         _gSyslog_A5=SetCurrentA5();
  36. #endif
  37.         
  38.         // have the component, and it is open.  Install the ETS patch
  39.         _gSyslog_oldETS=(ExitToShellUPP)NGetTrapAddress(_ExitToShell,ToolTrap);
  40.         NSetTrapAddress((UniversalProcPtr)_gSyslog_newETS,_ExitToShell,ToolTrap);
  41.         
  42.     } else {
  43.         // couldn't find the component
  44.         DisposePtr((Ptr)_gSyslogBuf);
  45.     }
  46.     
  47.     return;
  48. }
  49.  
  50.  
  51. #if defined(powerc) || defined(__powerc)
  52.  
  53. enum {
  54.     uppCallComponentProcInfo = kPascalStackBased
  55.         | RESULT_SIZE(kFourByteCode)
  56.         | STACK_ROUTINE_PARAMETER(1, kFourByteCode)
  57. };
  58.  
  59. /* A few macros to simplify the code (or does it make it more complex?  ;-) */
  60. #define CallComponentGlue(ptr) \
  61.     CallUniversalProc(CallComponentUPP,uppCallComponentProcInfo,(ptr))
  62.  
  63. #define PPC_Glue(parmsType) \
  64.     unsigned char flags; \
  65.     unsigned char size; \
  66.     short what; \
  67.     parmsType parms; \
  68.     ComponentInstance inst
  69.  
  70. #define SetupGlue(var,sel,type,ic)\
  71.     (var).flags=0;\
  72.     (var).size=sizeof(type);\
  73.     (var).what=(sel);\
  74.     (var).inst=(ic)
  75.  
  76. #define PPC_VoidGlue \
  77.     unsigned char flags; \
  78.     unsigned char size; \
  79.     short what; \
  80.     ComponentInstance inst
  81.  
  82. #define SetupVoidGlue(var,sel,ic)\
  83.     (var).flags=0;\
  84.     (var).size=0;\
  85.     (var).what=(sel);\
  86.     (var).inst=(ic)
  87.  
  88. #define SetGlueParm(var,ps,val) \
  89.     (var).parms.ps=(val)
  90.  
  91. pascal ComponentResult Comp_setlogmask(ComponentInstance inst,short maskpri){
  92.     ComponentResult err;
  93.     
  94.     #pragma options align=mac68k
  95.     // Remember that these must be in reverse order from the parameters
  96.     struct GlueParms {
  97.         short maskpri;
  98.     };
  99.     
  100.     typedef struct GlueParms GlueParms;
  101.     
  102.     struct ICCallGlue {
  103.         PPC_Glue(GlueParms);
  104.     };
  105.     
  106.     typedef struct ICCallGlue ICCallGlue;
  107.     #pragma options align=reset
  108.     
  109.     ICCallGlue glue;
  110.     
  111.     if (inst == (ComponentInstance)0) {
  112.         err = badComponentInstance;
  113.     } else {
  114.         // only one for the glue struct
  115.         SetupGlue(glue,ksetlogmaskSelector,GlueParms,inst);
  116.         // the glue struct, the selector code, the parameter struct, and the instance
  117.         
  118.         // one of these for each parameter
  119.         SetGlueParm(glue,maskpri,maskpri);
  120.         // the glue struct, the parameter struct item to set, and the function parameter to use
  121.         
  122.         // call the component now
  123.         err = CallComponentGlue(&glue);
  124.     }
  125.     
  126.     return err; // return the error
  127. }
  128.  
  129. pascal ComponentResult Comp_geterror(ComponentInstance inst,OSErr* errp){
  130.     ComponentResult err;
  131.     
  132.     #pragma options align=mac68k
  133.     struct GlueParms {
  134.         OSErr* errp;
  135.     };
  136.     typedef struct GlueParms GlueParms;
  137.     struct ICCallGlue {
  138.         PPC_Glue(GlueParms);
  139.     };
  140.     typedef struct ICCallGlue ICCallGlue;
  141.     #pragma options align=reset
  142.     
  143.     ICCallGlue glue;
  144.     
  145.     if (inst == (ComponentInstance)0) {
  146.         err = badComponentInstance;
  147.     } else {
  148.         SetupGlue(glue,kGetErrorSelector,GlueParms,inst);
  149.         
  150.         SetGlueParm(glue,errp,errp);
  151.         
  152.         err = CallComponentGlue(&glue);
  153.     }
  154.     return err;
  155. }
  156.  
  157. pascal ComponentResult Comp_openlog(ComponentInstance inst,const char* ident,
  158.         long logopt,short facility){
  159.     ComponentResult err;
  160.     
  161.     #pragma options align=mac68k
  162.     struct GlueParms {
  163.         short facility;
  164.         long logopt;
  165.         const char* ident;
  166.     };
  167.     typedef struct GlueParms GlueParms;
  168.     struct ICCallGlue {
  169.         PPC_Glue(GlueParms);
  170.     };
  171.     typedef struct ICCallGlue ICCallGlue;
  172.     #pragma options align=reset
  173.     
  174.     ICCallGlue glue;
  175.     
  176.     if (inst == (ComponentInstance)0) {
  177.         err = badComponentInstance;
  178.     } else {
  179.         SetupGlue(glue,kopenlogSelector,GlueParms,inst);
  180.         
  181.         SetGlueParm(glue,ident,ident);
  182.         SetGlueParm(glue,logopt,logopt);
  183.         SetGlueParm(glue,facility,facility);
  184.         
  185.         err = CallComponentGlue(&glue);
  186.     }
  187.     return err;
  188. }
  189.  
  190. pascal ComponentResult Comp_syslog(ComponentInstance inst,short priority,
  191.         const char* message){
  192.     ComponentResult err;
  193.     
  194.     #pragma options align=mac68k
  195.     struct GlueParms {
  196.         const char* message;
  197.         short priority;
  198.     };
  199.     typedef struct GlueParms GlueParms;
  200.     struct ICCallGlue {
  201.         PPC_Glue(GlueParms);
  202.     };
  203.     typedef struct ICCallGlue ICCallGlue;
  204.     #pragma options align=reset
  205.     
  206.     ICCallGlue glue;
  207.     
  208.     if (inst == (ComponentInstance)0) {
  209.         err = badComponentInstance;
  210.     } else {
  211.         SetupGlue(glue,ksyslogSelector,GlueParms,inst);
  212.         
  213.         SetGlueParm(glue,message,message);
  214.         SetGlueParm(glue,priority,priority);
  215.         
  216.         err = CallComponentGlue(&glue);
  217.     }
  218.     return err;
  219. }
  220.  
  221. pascal ComponentResult Comp_closelog(ComponentInstance inst){
  222.     ComponentResult err;
  223.     
  224.     #pragma options align=mac68k
  225.     struct ICCallGlue {
  226.         PPC_VoidGlue;
  227.     };
  228.     typedef struct ICCallGlue ICCallGlue;
  229.     #pragma options align=reset
  230.     
  231.     ICCallGlue glue;
  232.     
  233.     if (inst == (ComponentInstance)0) {
  234.         err = badComponentInstance;
  235.     } else {
  236.         SetupVoidGlue(glue,kcloselogSelector,inst);
  237.         
  238.         err = CallComponentGlue(&glue);
  239.     }
  240.     return err;
  241. }
  242.  
  243. pascal ComponentResult Comp_setfile(ComponentInstance inst,FSSpecPtr spec){
  244.     ComponentResult err;
  245.     
  246.     #pragma options align=mac68k
  247.     struct GlueParms {
  248.         FSSpecPtr spec;
  249.     };
  250.     typedef struct GlueParms GlueParms;
  251.     struct ICCallGlue {
  252.         PPC_Glue(GlueParms);
  253.     };
  254.     typedef struct ICCallGlue ICCallGlue;
  255.     #pragma options align=reset
  256.     
  257.     ICCallGlue glue;
  258.     
  259.     if (inst == (ComponentInstance)0) {
  260.         err = badComponentInstance;
  261.     } else {
  262.         SetupGlue(glue,kSetFileSelector,GlueParms,inst);
  263.         
  264.         SetGlueParm(glue,spec,spec);
  265.         
  266.         err = CallComponentGlue(&glue);
  267.     }
  268.     return err;
  269. }
  270.  
  271. #endif
  272.  
  273.